
let operationHistoryData = [];

// DOM元素引用
let customerCodeEl;
let pageStatusEl;
let statusMessageEl;
let smokingDataContainer;
let operationHistory;
let autoFillBtn;
let createPurchaseOrderBtn;
let fetchDataBtn;
let smokingData = null;

/**
 * 更新客户编码显示
 */
function updateCustomerCode(code) {
    console.log('全局updateCustomerCode被调用，参数:', code);
    if (!customerCodeEl) {
        console.error('customerCodeEl元素未初始化');
        customerCodeEl = document.getElementById('customerCode');
        if (!customerCodeEl) {
            console.error('无法获取customerCode元素');
            return;
        }
    }
    console.log('更新前customerCodeEl内容:', customerCodeEl.textContent);
    customerCodeEl.textContent = code || '未获取';
    console.log('更新后customerCodeEl内容:', customerCodeEl.textContent);
}

/**
 * 更新页面状态显示
 */
function updatePageStatus(statusText, type = 'info') {
    if (!pageStatusEl) {
        pageStatusEl = document.getElementById('pageStatus');
    }
    pageStatusEl.textContent = statusText;
    const statusClasses = {
        info: 'status-loading',
        success: 'status-ready',
        error: 'status-error',
        warning: 'status-warning'
    };
    pageStatusEl.className = `info-value ${statusClasses[type] || 'status-loading'}`;
}

/**
 * 显示状态消息
 */
function showStatusMessage(message, type = 'info') {
    const statusIcon = statusMessageEl.querySelector('.status-icon');
    const statusText = statusMessageEl.querySelector('.status-text');

    const icons = {
        info: 'ℹ️',
        success: '✅',
        error: '❌',
        warning: '⚠️'
    };

    statusIcon.textContent = icons[type] || icons.info;
    statusText.textContent = message;

    statusMessageEl.className = `status-message ${type}`;
    statusMessageEl.classList.remove('hidden');

    if (type === 'success' || type === 'info') {
        setTimeout(() => {
            statusMessageEl.classList.add('hidden');
        }, 3000);
    }
}

/**
 * 更新操作历史显示
 */
function updateOperationHistoryDisplay() {
    if (!operationHistory) {
        operationHistory = document.getElementById('operationHistory');
    }
    if (operationHistoryData.length === 0) {
        operationHistory.innerHTML = `
            <div class="history-placeholder">
                <span class="placeholder-icon">📝</span>
                <p>暂无操作记录</p>
            </div>
        `;
        return;
    }

    const historyList = operationHistoryData.slice(-5).reverse().map(item => `
        <div class="history-item">
            <div class="history-header">
                <span class="history-action">${item.action}</span>
                <span class="history-result ${item.result === '成功' ? 'success' : 'error'}">${item.result}</span>
            </div>
            <div class="history-details">
                <span class="history-time">${item.timestamp}</span>
                ${item.details ? `<span class="history-desc">${item.details}</span>` : ''}
            </div>
        </div>
    `).join('');

    operationHistory.innerHTML = `
        <div class="history-list">
            ${historyList}
        </div>
    `;
}

// 注入到页面的函数 - 获取客户编码
function getCustomerCode() {
    try {
        console.log('=== 开始获取客户编码 ===');
        console.log('当前页面URL:', window.location.href);
        console.log('页面加载状态:', document.readyState);
        console.log('页面标题:', document.title);
        console.log('DOM元素总数:', document.querySelectorAll('*').length);

        // 检查页面是否包含目标内容（更灵活的检测）
        const hasTargetContent = document.querySelector('.idx_tjjy_infobox') ||
            document.querySelector('#idx_tjjy_cust_code') ||
            document.body.innerHTML.includes('编码：');

        console.log('页面是否包含目标内容:', hasTargetContent);

        // 检查页面内容是否已加载
        const pageContentLoaded = document.querySelector('.idx_tjjy_infobox') ||
            document.getElementById('idx_tjjy_cust_code') ||
            document.body.textContent.includes('编码：');

        if (!pageContentLoaded) {
            console.log('页面内容尚未加载完成，关键元素未找到');
            return null;
        }

        // 如果页面未完全加载且没有目标内容，返回null等待重试
        if (document.readyState !== 'complete' && !hasTargetContent) {
            console.log('页面尚未完全加载且无目标内容，readyState:', document.readyState);
            return null;
        }

        // 查找客户编码元素
        const codeElement = document.getElementById('idx_tjjy_cust_code');
        console.log('查找id为idx_tjjy_cust_code的元素:', codeElement);
        console.log('元素是否存在:', !!codeElement);

        if (codeElement) {
            console.log('元素的父级:', codeElement.parentElement);
            console.log('元素的HTML:', codeElement.outerHTML);
            console.log('元素是否可见:', codeElement.offsetParent !== null);
            console.log('元素的样式display:', window.getComputedStyle(codeElement).display);
            console.log('元素的样式visibility:', window.getComputedStyle(codeElement).visibility);

            const code = codeElement.textContent ? codeElement.textContent.trim() : '';
            console.log('找到客户编码元素，原始内容:', `"${codeElement.textContent}"`);
            console.log('处理后的编码:', `"${code}"`);
            console.log('编码长度:', code.length);
            console.log('编码是否为数字:', /^\d+$/.test(code));
            console.log('编码是否为12位数字:', /^\d{12}$/.test(code));

            // 检查编码是否有效（至少6位数字）
            if (code && /^\d{6,}$/.test(code)) {
                console.log('成功获取到有效的客户编码:', code);
                return code;
            } else {
                console.log('客户编码元素存在但内容无效:', code);
                console.log('可能原因: 元素内容为空或不是有效的数字编码');
            }
        } else {
            console.log('未找到id为idx_tjjy_cust_code的元素');
            // 检查是否有类似的元素
            const similarElements = document.querySelectorAll('[id*="cust_code"], [id*="customer"], [class*="cust_code"]');
            console.log('找到类似的元素:', similarElements.length, '个');
            similarElements.forEach((el, index) => {
                console.log(`类似元素${index + 1}:`, el.id, el.className, el.textContent?.trim());
            });
        }

        // 备用搜索方法1：查找所有span元素中的数字编码
        console.log('开始备用搜索方法1：查找span元素中的编码');
        const allSpans = document.querySelectorAll('span');
        console.log('页面中共有', allSpans.length, '个span元素');

        for (let span of allSpans) {
            const text = span.textContent ? span.textContent.trim() : '';
            if (/^\d{6,}$/.test(text)) {
                console.log('找到可能的编码元素:', span, '内容:', text);
                return text;
            }
        }

        // 备用搜索方法2：查找包含"编码"文字的元素附近
        console.log('开始备用搜索方法2：查找包含"编码"文字的元素');
        const allElements = document.querySelectorAll('*');
        for (let element of allElements) {
            const elementText = element.textContent || '';
            if (elementText.includes('编码：') || elementText.includes('编码:')) {
                console.log('找到包含"编码："的元素:', element);

                // 查找该元素内部的数字
                const match = elementText.match(/编码[：:]\s*(\d{6,})/);
                if (match) {
                    console.log('在元素文本中找到编码:', match[1]);
                    return match[1];
                }

                // 查找子元素中的编码
                const spans = element.querySelectorAll('span');
                for (let span of spans) {
                    const spanText = span.textContent ? span.textContent.trim() : '';
                    if (/^\d{6,}$/.test(spanText)) {
                        console.log('在子元素中找到编码:', spanText);
                        return spanText;
                    }
                }
            }
        }

        console.log('所有搜索方法都未找到客户编码');
        return null;

    } catch (error) {
        console.error('获取客户编码时发生错误:', error);
        return null;
    }
}

/**
 * 添加操作历史记录
 */
function addOperationHistory(action, result, details = '') {
    const timestamp = new Date().toLocaleString('zh-CN', {
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit'
    });

    const historyItem = {
        timestamp,
        action,
        result,
        details
    };

    operationHistoryData.unshift(historyItem);

    // 限制历史记录数量
    if (operationHistoryData.length > 10) {
        operationHistoryData = operationHistoryData.slice(0, 10);
    }

    updateOperationHistoryDisplay();
}

/**
 * 自动检测客户编码
 */
function autoDetectCustomerCode() {
    console.log('开始自动检测客户编码...');

    // 返回Promise以便调用者可以等待完成
    return new Promise((resolve, reject) => {
        chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
            if (chrome.runtime.lastError) {
                console.error('客户编码检测 - chrome.tabs.query失败:', chrome.runtime.lastError);
                updateCustomerCode('查询失败');
                reject(chrome.runtime.lastError);
                return;
            }

            console.log('客户编码检测 - 获取到标签页:', tabs);

            if (!tabs || tabs.length === 0) {
                console.error('客户编码检测 - 无活动标签页');
                updateCustomerCode('无标签页');
                reject(new Error('无活动标签页'));
                return;
            }

            const currentUrl = tabs[0].url;
            console.log('检测客户编码 - 当前页面URL:', currentUrl);

            // 只在目标页面尝试获取客户编码
            if (!currentUrl || !currentUrl.includes('wdk')) {
                console.log('当前不在目标页面，无法获取客户编码');
                showStatusMessage('当前不在目标页面，无法获取客户编码', 'warning');
                updateCustomerCode('非目标页面');
                addOperationHistory('自动检测客户编码', '跳过', '非目标页面');
                resolve('非目标页面');
                return;
            }

            // 开始尝试获取客户编码
            attemptGetCustomerCode(tabs[0])
                .then(result => {
                    console.log('客户编码获取成功:', result);
                    resolve(result);
                })
                .catch(error => {
                    console.error('客户编码获取失败:', error);
                    updateCustomerCode('获取失败');
                    addOperationHistory('自动检测客户编码', '失败', error.message);
                    reject(error);
                });
        });
    });
}

/**
 * 尝试获取客户编码（带重试机制）
 */
function attemptGetCustomerCode(tab) {
    return new Promise((resolve, reject) => {
        console.log('开始尝试获取客户编码，标签页ID:', tab.id);

        // 尝试获取客户编码，如果失败则延迟重试
        function attemptGetCode(retryCount = 0) {
            console.log(`第 ${retryCount + 1} 次尝试获取客户编码`);

            try {
                chrome.scripting.executeScript({
                    target: { tabId: tab.id },
                    function: getCustomerCode
                }, function (result) {
                    // 处理可能的运行时错误
                    if (chrome.runtime.lastError) {
                        console.error('执行脚本失败:', chrome.runtime.lastError);
                        if (retryCount < 2) {
                            console.log('脚本执行失败，将重试...');
                            showStatusMessage(`脚本执行失败，正在重试... (${retryCount + 1}/3)`, 'warning');
                            setTimeout(() => attemptGetCode(retryCount + 1), 1500);
                        } else {
                            updateCustomerCode('脚本失败');
                            showStatusMessage('脚本执行失败: ' + chrome.runtime.lastError.message, 'error');
                            addOperationHistory('自动检测客户编码', '失败', '脚本执行失败: ' + chrome.runtime.lastError.message);
                            reject(chrome.runtime.lastError);
                        }
                        return;
                    }

                    // 检查结果是否为空
                    if (!result || !result[0]) {
                        console.error('脚本执行结果为空');
                        if (retryCount < 2) {
                            showStatusMessage(`脚本结果为空，正在重试... (${retryCount + 1}/3)`, 'warning');
                            setTimeout(() => attemptGetCode(retryCount + 1), 1500);
                        } else {
                            updateCustomerCode('结果为空');
                            showStatusMessage('脚本执行结果为空', 'error');
                            addOperationHistory('自动检测客户编码', '失败', '脚本执行结果为空');
                            reject(new Error('脚本执行结果为空'));
                        }
                        return;
                    }

                    // 处理成功获取的结果
                    const customerCode = result[0].result;
                    console.log(`第 ${retryCount + 1} 次尝试获取到的客户编码:`, customerCode);
                    console.log('脚本执行结果详情:', result[0]);

                    if (customerCode) {
                        console.log('准备更新UI显示客户编码:', customerCode);
                        updateCustomerCode(customerCode);
                        showStatusMessage('已自动检测到客户编码: ' + customerCode, 'success');
                        addOperationHistory('自动检测客户编码', '成功', '编码: ' + customerCode);
                        resolve(customerCode);
                    } else if (retryCount < 2) {
                        // 如果没有找到编码且重试次数少于3次，则延迟重试
                        console.log(`第 ${retryCount + 1} 次尝试未找到编码，准备重试...`);
                        showStatusMessage(`正在重试检测客户编码... (${retryCount + 1}/3)`, 'info');
                        setTimeout(() => attemptGetCode(retryCount + 1), 2000); // 增加重试间隔
                    } else {
                        console.log('所有重试都失败，最终未找到客户编码');
                        updateCustomerCode('未找到');
                        showStatusMessage('页面中未找到客户编码元素，请确保在正确的页面并等待页面完全加载。请查看控制台日志获取详细信息。', 'warning');
                        addOperationHistory('自动检测客户编码', '失败', '多次尝试后仍未找到客户编码元素');
                        resolve(null);
                    }
                });
            } catch (error) {
                // 处理可能的JavaScript异常
                console.error(`第 ${retryCount + 1} 次尝试执行脚本时出错:`, error);
                console.error('错误详情:', {
                    message: error.message,
                    stack: error.stack,
                    name: error.name
                });
                console.error('当前标签页信息:', tab);

                if (retryCount < 2) {
                    console.log(`脚本执行出错，准备第 ${retryCount + 2} 次重试...`);
                    showStatusMessage(`脚本执行出错，正在重试... (${retryCount + 1}/3)`, 'warning');
                    setTimeout(() => attemptGetCode(retryCount + 1), 1500 + retryCount * 500);
                } else {
                    console.log('所有脚本执行尝试都失败');
                    updateCustomerCode('执行错误');
                    showStatusMessage('脚本执行出错，请刷新页面后重试。请查看控制台日志获取详细错误信息。', 'error');
                    addOperationHistory('自动检测客户编码', '失败', '脚本执行错误: ' + error.message);
                    resolve(null);
                }
            }
        }

        // 开始尝试获取编码
        attemptGetCode();
    });
}

/**
 * 注入到页面的函数 - 提取网页数据
 */

/**
 * 初始化页面
 */
function initializePage() {
    console.log('开始初始化页面...');

    // 初始化操作历史
    updateOperationHistoryDisplay();

    // 显示初始状态消息
    showStatusMessage('插件已就绪，正在检测页面状态...', 'info');

    // 先检查页面状态，然后再检测客户编码
    checkPageStatus()
        .then(() => {
            console.log('页面状态检测完成，开始检测客户编码...');
            showStatusMessage('页面状态检测完成，正在检测客户编码...', 'info');
            return autoDetectCustomerCode();
        })
        .catch(error => {
            console.error('初始化过程中发生错误:', error);
            showStatusMessage('初始化失败: ' + error.message, 'error');
        });
}

/**
 * 检查页面状态
 */
function checkPageStatus() {
    // 先设置检测中状态
    updatePageStatus('检测中...', 'info');

    console.log('开始检查页面状态...');
    // 返回Promise以便调用者可以等待完成
    return new Promise((resolve, reject) => {
        chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
            if (chrome.runtime.lastError) {
                console.error('chrome.tabs.query失败:', chrome.runtime.lastError);
                updatePageStatus('检测失败', 'error');
                reject(chrome.runtime.lastError);
                return;
            }

            console.log('获取到标签页:', tabs);

            if (!tabs || tabs.length === 0) {
                console.error('无活动标签页');
                updatePageStatus('无标签页', 'error');
                reject(new Error('无活动标签页'));
                return;
            }

            const currentUrl = tabs[0].url;
            console.log('当前页面URL:', currentUrl);

            if (currentUrl && currentUrl.includes('wdk')) {
                updatePageStatus('正常 - 卷烟列表页面', 'success');
                console.log('检测到卷烟列表页面');
                resolve(tabs[0]);
            } else {
                updatePageStatus('非卷烟列表页面', 'warning');
                console.log('当前不在卷烟列表页面');
                resolve(tabs[0]); // 即使不是目标页面也resolve，让后续流程继续
            }
        });
    });
}

document.addEventListener('DOMContentLoaded', function () {
    console.log('=== DOM内容加载完成，开始初始化 ===');

    try {
        // 初始化DOM元素引用
        console.log('正在初始化DOM元素引用...');
        autoFillBtn = document.getElementById('autoFillBtn');
        createPurchaseOrderBtn = document.getElementById('createPurchaseOrderBtn');
        fetchDataBtn = document.getElementById('fetchDataBtn');
        customerCodeEl = document.getElementById('customerCode');
        pageStatusEl = document.getElementById('pageStatus');
        statusMessageEl = document.getElementById('statusMessage');
        smokingDataContainer = document.getElementById('smokingDataContainer');
        operationHistory = document.getElementById('operationHistory');

        console.log('DOM元素引用结果:', {
            autoFillBtn: !!autoFillBtn,
            createPurchaseOrderBtn: !!createPurchaseOrderBtn,
            fetchDataBtn: !!fetchDataBtn,
            customerCodeEl: !!customerCodeEl,
            pageStatusEl: !!pageStatusEl,
            statusMessageEl: !!statusMessageEl,
            smokingDataContainer: !!smokingDataContainer,
            operationHistory: !!operationHistory
        });

        // 检查关键元素是否存在
        if (!createPurchaseOrderBtn) {
            console.error('关键错误: 新建采购单按钮元素未找到!');
            return;
        }

        // 绑定事件监听器
        console.log('正在绑定事件监听器...');

        if (fetchDataBtn) {
            fetchDataBtn.addEventListener('click', handleDataFetch);
            console.log('✅ fetchDataBtn 事件监听器已绑定');
        } else {
            console.error('❌ fetchDataBtn 元素未找到，无法绑定事件');
        }

        if (autoFillBtn) {
            autoFillBtn.addEventListener('click', handleAutoFill);
            console.log('✅ autoFillBtn 事件监听器已绑定');
        } else {
            console.error('❌ autoFillBtn 元素未找到，无法绑定事件');
        }

        if (createPurchaseOrderBtn) {
            createPurchaseOrderBtn.addEventListener('click', function () {
                console.log('🔥 新建采购单按钮被点击');
                try {
                    // 直接在这里定义并调用新建采购单逻辑，确保作用域正确
                    showLoading(createPurchaseOrderBtn);
                    addOperationHistory('新建采购单', '开始');
                    console.log('addOperationHistory调用完成');
                    new Promise((resolve, reject) => {
                        chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
                            if (chrome.runtime.lastError) {
                                return reject(chrome.runtime.lastError);
                            }
                            if (!tabs || tabs.length === 0) {
                                return reject(new Error('无活动标签页'));
                            }
                            resolve(tabs[0]);
                        });
                    })
                        .then(tab => {
                            showStatusMessage('正在获取客户编码...', 'info');
                            return attemptGetCustomerCode(tab);
                        })
                        .then(customerCode => {
                            if (!customerCode) {
                                throw new Error('未能获取到客户编码');
                            }
                            showStatusMessage('正在提取网页数据...', 'info');
                            return extractWebpageData(customerCode);
                        })
                        .then(webpageData => {
                            showStatusMessage('正在提交到轻流API...', 'info');
                            return submitToQingflowAPI(webpageData);
                        })
                        .then(result => {
                            hideLoading(createPurchaseOrderBtn);
                            showStatusMessage('采购单创建成功', 'success');
                            addOperationHistory('新建采购单', '成功', `客户编码: ${result.customer_code || '未知'}`);
                            return result;
                        })
                        .catch(error => {
                            hideLoading(createPurchaseOrderBtn);
                            hideLoading(createPurchaseOrderBtn);
                            showStatusMessage(`操作失败: ${error.message}`, 'error');
                            addOperationHistory('新建采购单', '失败', error.message);
                        });
                } catch (error) {
                    console.error('调用新建采购单逻辑时出错:', error);
                    console.error('错误堆栈:', error.stack);
                }
            });
        } else {
            console.error('❌ createPurchaseOrderBtn 元素未找到，无法绑定事件');
        }
        // 初始化页面
        initializePage();

    } catch (error) {
        console.error('=== DOM初始化过程中发生错误 ===');
    }

    /**
     * 处理获取数据功能
     */
    function handleDataFetch() {
        showLoading(fetchDataBtn);
        addOperationHistory('获取订烟数据', '开始');

        new Promise((resolve, reject) => {
            chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
                if (chrome.runtime.lastError) {
                    return reject(chrome.runtime.lastError);
                }
                if (!tabs || tabs.length === 0) {
                    return reject(new Error('无活动标签页'));
                }
                resolve(tabs[0]);
            });
        })
            .then(tab => {
                showStatusMessage('正在获取客户编码...', 'info');
                return attemptGetCustomerCode(tab);
            })
            .then(customerCode => {
                if (!customerCode) {
                    throw new Error('未能获取到客户编码');
                }
                showStatusMessage('正在获取订烟数据...', 'info');
                return fetchSmokingData(customerCode);
            })
            .then(data => {
                hideLoading(fetchDataBtn);
                showStatusMessage('订烟数据获取成功', 'success');

                // 处理API返回的数据结构
                const actualData = data.data || data;
                smokingData = actualData;
                updateSmokingDataDisplay(actualData);
                addOperationHistory('获取订烟数据', '成功', `获取到 ${actualData.length || 0} 条数据`);
                saveSmokingDataToStorage(actualData);
                return actualData;
            })
            .catch(error => {
                hideLoading(fetchDataBtn);
                showStatusMessage(`获取数据失败: ${error.message}`, 'error');
                addOperationHistory('获取订烟数据', '失败', error.message);
            });
    }



    /**
     * 调用API获取订烟数据
     */
    function fetchSmokingData(customerCode) {
        const baseUrl = 'https://scrm.zuixiyu.com/Smioking/api/smoking/fixed-tobacco-list';
        const params = new URLSearchParams();
        if (customerCode) {
            params.append('customer_code', customerCode);
        }
        const apiUrl = `${baseUrl}?${params.toString()}`;
        return fetch(apiUrl, {
            method: 'GET',
            headers: {
                'Content-Type': 'application/json',
            }
        })
            .then(response => {
                console.log('API响应状态:', response.status, response.statusText);
                if (!response.ok) {
                    throw new Error(`网络请求失败: ${response.status} ${response.statusText}`);
                }
                return response.json();
            })
            .then(data => {
                console.log('API返回数据:', data);
                // 检查API返回的数据结构 - fixed_tobacco_table返回的数据格式
                const actualData = data.data || []; // 获取香烟数据列表

                // 调试：输出香烟产品详细信息
                if (actualData && actualData.length > 0) {
                    actualData.forEach((item, index) => {
                        console.log(`香烟${index + 1}:`, {
                            id: item.id,
                            name: item.name,
                            wholesale_price: item.wholesale_price,
                            retail_price: item.retail_price,
                            default_quantity: item.default_quantity,
                            category: item.category
                        });
                    });
                }

                smokingData = actualData;
                console.log('[DEBUG] fetchSmokingData成功，设置smokingData数量:', actualData.length);
                showStatusMessage('必定烟表数据获取成功', 'success');
                updateSmokingDataDisplay(actualData);
                addOperationHistory('获取必定烟表数据', '成功', `获取到 ${actualData.length || 0} 条数据`);
                saveSmokingDataToStorage(actualData);
                return actualData;
            })
            .catch(error => {
                console.error('API调用失败:', error);
                showStatusMessage('获取必定烟表数据失败: ' + error.message, 'error');
                addOperationHistory('获取必定烟表数据', '失败', error.message);
                throw error; // 重新抛出错误，让上层处理
            });
    }

    /**
     * @ai-handler
     * 智能自动填写处理函数
     * 基于API数据进行精确商品匹配和数量填写
     * 包含完整的错误处理和用户反馈机制
     */
    function handleAutoFill() {
        // 检查是否有订烟数据，如果没有则先获取
        if (!smokingData || smokingData.length === 0) {
            showStatusMessage('订烟数据为空，正在重新获取...', 'warning');
            addOperationHistory('智能填写', '开始', '数据为空，重新获取中');

            // 先获取客户编码
            autoDetectCustomerCode()
                .then(customerCode => {
                    if (!customerCode) {
                        throw new Error('无法获取客户编码，请确保在正确的页面');
                    }
                    return fetchSmokingData(customerCode);
                })
                .then(data => {
                    const actualData = data.data || data;
                    smokingData = actualData;
                    if (smokingData && smokingData.length > 0) {
                        executeIntelligentAutoFill();
                    } else {
                        throw new Error('无法获取订烟数据，请检查网络连接或稍后重试');
                    }
                })
                .catch(error => {
                    showStatusMessage('获取数据失败: ' + error.message, 'error');
                    addOperationHistory('智能填写', '失败', error.message);
                });
            return;
        }

        executeIntelligentAutoFill();
    }

    /**
     * 执行智能自动填写
     */
    function executeIntelligentAutoFill() {
        showLoading(autoFillBtn);
        showStatusMessage('正在执行智能填写...', 'info');
        addOperationHistory('智能填写', '开始', `基于 ${smokingData.length} 条API数据`);

        chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
            chrome.scripting.executeScript({
                target: { tabId: tabs[0].id },
                function: quickFillOrdersWithData,
                args: [smokingData]
            }, function (result) {
                hideLoading(autoFillBtn);
                if (chrome.runtime.lastError) {
                    showStatusMessage('智能填写失败: ' + chrome.runtime.lastError.message, 'error');
                    addOperationHistory('智能填写', '失败', chrome.runtime.lastError.message);
                } else {
                    showStatusMessage('智能填写完成', 'success');
                    addOperationHistory('智能填写', '成功', '已完成基于API数据的商品匹配填写');
                }
            });
        });
    }

    /**
     * 显示加载状态
     */
    function showLoading(button) {
        button.disabled = true;
        button.style.opacity = '0.6';
        const originalHTML = button.innerHTML;
        button.setAttribute('data-original-text', originalHTML);
        button.innerHTML = '<span class="btn-icon">⏳</span>处理中...';
    }

    /**
     * 隐藏加载状态
     */
    function hideLoading(button) {
        button.disabled = false;
        button.style.opacity = '1';
        const originalText = button.getAttribute('data-original-text');
        button.innerHTML = originalText;
    }

    /**
     * 显示消息
     */
    function showMessage(message, type = 'info') {
        // 创建消息元素
        const messageEl = document.createElement('div');
        messageEl.className = `message message-${type}`;
        messageEl.textContent = message;
        messageEl.style.cssText = `
            position: fixed;
            top: 10px;
            right: 10px;
            padding: 10px 15px;
            border-radius: 4px;
            color: white;
            font-size: 12px;
            z-index: 1000;
            animation: slideIn 0.3s ease;
        `;

        // 设置背景色
        switch (type) {
            case 'success':
                messageEl.style.backgroundColor = '#28a745';
                break;
            case 'error':
                messageEl.style.backgroundColor = '#dc3545';
                break;
            case 'info':
            default:
                messageEl.style.backgroundColor = '#17a2b8';
                break;
        }

        document.body.appendChild(messageEl);

        // 3秒后自动移除
        setTimeout(() => {
            if (messageEl.parentNode) {
                messageEl.parentNode.removeChild(messageEl);
            }
        }, 3000);
    }

    /**
     * 提取网页数据
     */
    function extractWebpageData(customerCode) {
        console.log('🚀 extractWebpageData函数被调用，customerCode:', customerCode);
        return new Promise((resolve, reject) => {
            chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
                if (chrome.runtime.lastError) {
                    reject(new Error('提取网页数据失败: ' + chrome.runtime.lastError.message));
                    return;
                }

                if (!tabs || tabs.length === 0) {
                    console.error('🔍 未找到活动标签页');
                    reject(new Error('未找到活动标签页'));
                    return;
                }

                // 检查chrome.scripting API是否可用
                if (!chrome.scripting || !chrome.scripting.executeScript) {
                    reject(new Error('浏览器不支持脚本注入功能'));
                    return;
                }

                chrome.scripting.executeScript({
                    target: { tabId: tabs[0].id },
                    function: function extractPageData() {
                        console.log('🎯 extractPageData注入函数开始执行');
                        try {
                            const tobacco_list = [];
                            let total_amount = 0;
                            const extracted_prices = [];
                            const processedNames = new Set(); // 用于去重

                            // 提取订单表格中的数据
                            console.log('🌐 === 开始数据提取调试 ===');
                            const orderRows = document.querySelectorAll('.cq_buy_main_grid_body .cq_buy_main_grid_row');
                            console.log('🌐 找到的订单行数量:', orderRows.length);

                            // 调试：检查是否有重复的行
                            const rowTexts = [];
                            orderRows.forEach((row, index) => {
                                const nameElement = row.querySelector('.cq_buy_main_grid_c2');
                                const name = nameElement ? nameElement.textContent.trim() : '';
                                rowTexts.push(`第${index + 1}行: ${name}`);
                            });
                            console.log('🌐 所有行的商品名称:', rowTexts);

                            // 检查是否有重复的商品名称
                            const nameSet = new Set();
                            const duplicateNames = [];
                            rowTexts.forEach(text => {
                                const name = text.split(': ')[1];
                                if (nameSet.has(name) && name) {
                                    duplicateNames.push(name);
                                }
                                nameSet.add(name);
                            });
                            if (duplicateNames.length > 0) {
                                console.warn('🌐 ⚠️ 发现重复的商品名称:', duplicateNames);
                            }

                            if (orderRows.length === 0) {
                                // 尝试其他可能的选择器
                                const alternativeRows = document.querySelectorAll('tr[class*="row"], .order-row, .product-row');
                                console.log('🌐 备用选择器找到的行数:', alternativeRows.length);
                            }

                            orderRows.forEach((row, index) => {
                                try {
                                    // 提取商品名称
                                    const nameElement = row.querySelector('.cq_buy_main_grid_c2');
                                    const name = nameElement ? nameElement.textContent.trim() : '';

                                    // 提取批发价
                                    const wholesalePriceElement = row.querySelector('.cq_buy_main_grid_c3');
                                    const wholesale_price = wholesalePriceElement ? parseFloat(wholesalePriceElement.textContent.trim()) || 0 : 0;


                                    // 提取零售价
                                    const retailPriceElement = row.querySelector('.cq_buy_main_grid_c4');
                                    const retail_price = retailPriceElement ? parseFloat(retailPriceElement.textContent.trim()) || 0 : 0;

                                    // 提取订购量
                                    const quantityElement = row.querySelector('.cq_buy_main_grid_c6 input');
                                    const quantity = quantityElement ? parseInt(quantityElement.value) || 0 : 0;

                                    // 提取金额
                                    const amountElement = row.querySelector('.cq_buy_main_grid_c7');
                                    const amount = amountElement ? parseFloat(amountElement.textContent.trim()) || 0 : 0;

                                    if (name && quantity > 0) {
                                        // 检查是否已经处理过这个商品
                                        if (processedNames.has(name)) {
                                            console.log(`🌐 ⚠️ 跳过重复商品: ${name}`);
                                            return; // 跳过重复的商品
                                        }

                                        // 标记为已处理
                                        processedNames.add(name);

                                        const tobacco_item = {
                                            name: name,
                                            wholesale_price: wholesale_price,
                                            retail_price: retail_price,
                                            quantity: quantity,
                                            total_price: amount
                                        };

                                        console.log(`🌐 处理第${index + 1}行数据:`, {
                                            name: name,
                                            wholesale_price: wholesale_price,
                                            retail_price: retail_price,
                                            quantity: quantity,
                                            amount: amount
                                        });

                                        tobacco_list.push(tobacco_item);
                                        console.log(`🌐 已添加商品到tobacco_list，当前数量: ${tobacco_list.length}`);
                                        total_amount += amount;

                                        // 记录提取的价格信息
                                        extracted_prices.push({
                                            name: name,
                                            wholesale_price: wholesale_price,
                                            retail_price: retail_price
                                        });

                                    } else {
                                        console.log(`🌐 ❌ 第${index + 1}行数据无效 (name: "${name}", quantity: ${quantity})`);
                                    }

                                } catch (rowError) {
                                    console.error(`🌐 ❌ 处理第${index + 1}行数据时出错:`, rowError);
                                }
                            });

                            console.log('🌐 === 数据提取完成 ===');
                            console.log('🌐 tobacco_list原始数量:', tobacco_list.length);
                            console.log('🌐 tobacco_list内容预览:', tobacco_list.slice(0, 5)); // 显示前5个

                            // 检查tobacco_list是否有重复数据
                            const tobaccoNames = tobacco_list.map(item => item.name);
                            const uniqueNames = new Set(tobaccoNames);
                            if (tobaccoNames.length !== uniqueNames.size) {
                                console.warn('🌐 ⚠️ tobacco_list中发现重复数据!');
                                console.warn('🌐 总数量:', tobaccoNames.length, '唯一数量:', uniqueNames.size);

                                // 找出重复的商品名称
                                const duplicates = tobaccoNames.filter((name, index) => tobaccoNames.indexOf(name) !== index);
                                console.warn('🌐 重复的商品:', [...new Set(duplicates)]);

                                // 去重处理：保留每个商品的第一个出现
                                const uniqueTobaccoList = [];
                                const seenNames = new Set();

                                tobacco_list.forEach(item => {
                                    if (!seenNames.has(item.name)) {
                                        seenNames.add(item.name);
                                        uniqueTobaccoList.push(item);
                                    }
                                });

                                tobacco_list = uniqueTobaccoList;
                                console.log('🌐 ✅ 去重完成，tobacco_list最终数量:', tobacco_list.length);
                            } else {
                                console.log('🌐 ✅ tobacco_list无重复数据，最终数量:', tobacco_list.length);
                            }

                            // 也尝试从总计区域获取总金额
                            const totalAmountElement = document.querySelector('.total_price');
                            if (totalAmountElement) {
                                const totalFromPage = parseFloat(totalAmountElement.textContent.trim()) || 0;
                                console.log('🌐 从.total_price获取到总金额:', totalFromPage);
                                if (totalFromPage > 0) {
                                    total_amount = totalFromPage;
                                }
                            } else {
                                console.log('🌐 未找到.total_price元素');
                            }

                            // 计算汇总数据（基于订购量不为0的商品）
                            let calculated_total_spec = 0;  // 品牌规格总数
                            let calculated_total_qty = 0;   // 订单总量
                            let calculated_total_price = 0; // 订单总金额（使用批发价）

                            // 遍历tobacco_list计算汇总数据
                            tobacco_list.forEach(item => {
                                if (item.quantity > 0) {
                                    calculated_total_spec += 1;  // 每个有订购量的商品算作1个品牌规格
                                    calculated_total_qty += item.quantity;  // 累加订购数量
                                    calculated_total_price += item.wholesale_price * item.quantity;  // 使用批发价计算总金额
                                }
                            });

                            console.log('🌐 计算得出的汇总数据:');
                            console.log('🌐 - 品牌规格总数:', calculated_total_spec);
                            console.log('🌐 - 订单总量:', calculated_total_qty);
                            console.log('🌐 - 订单总金额(批发价):', calculated_total_price);

                            // 尝试从页面元素获取汇总数据（作为备用）
                            let page_total_spec = 0;
                            let page_total_qty = 0;
                            let page_total_price = 0;

                            // 品牌规格
                            const totalSpecElement = document.querySelector('.total_spec');
                            if (totalSpecElement) {
                                page_total_spec = parseInt(totalSpecElement.textContent.trim()) || 0;
                                console.log('🌐 页面品牌规格:', page_total_spec);
                            } else {
                                console.log('🌐 未找到.total_spec元素');
                            }

                            // 订单总量
                            const totalQtyElement = document.querySelector('.total_qty');
                            if (totalQtyElement) {
                                page_total_qty = parseInt(totalQtyElement.textContent.trim()) || 0;
                                console.log('🌐 页面订单总量:', page_total_qty);
                            } else {
                                console.log('🌐 未找到.total_qty元素');
                            }

                            // 总额（使用更具体的选择器）
                            const totalPriceElement = document.querySelector('.cq_buy_main_order_sum_amont.total_price');
                            if (totalPriceElement) {
                                page_total_price = parseFloat(totalPriceElement.textContent.trim()) || 0;
                                console.log('🌐 页面总价:', page_total_price);
                            } else {
                                console.log('🌐 未找到.cq_buy_main_order_sum_amont.total_price元素');
                            }

                            // 使用计算得出的数据，如果页面数据更准确则使用页面数据
                            const final_total_spec = calculated_total_spec > 0 ? calculated_total_spec : page_total_spec;
                            const final_total_qty = calculated_total_qty > 0 ? calculated_total_qty : page_total_qty;
                            const final_total_price = calculated_total_price > 0 ? calculated_total_price : page_total_price;

                            console.log('🌐 最终使用的汇总数据:');
                            console.log('🌐 - 品牌规格总数:', final_total_spec);
                            console.log('🌐 - 订单总量:', final_total_qty);
                            console.log('🌐 - 订单总金额:', final_total_price);

                            const result = {
                                tobacco_list: tobacco_list,
                                total_amount: final_total_price,  // 使用计算得出的总金额
                                total_spec: final_total_spec,     // 使用计算得出的品牌规格总数
                                total_qty: final_total_qty,       // 使用计算得出的订单总量
                                total_price: final_total_price,   // 使用计算得出的总金额
                                extracted_prices: extracted_prices,
                                page_url: window.location.href,
                                extraction_time: new Date().toISOString()
                            };
                            return result;

                        } catch (error) {
                            console.error('🌐 错误堆栈:', error.stack);
                            return {
                                tobacco_list: [],
                                total_amount: 0,
                                total_spec: 0,
                                total_qty: 0,
                                total_price: 0,
                                extracted_prices: [],
                                page_url: window.location.href,
                                error: error.message
                            };
                        }
                    }
                }).then((result) => {
                    console.log('🔍 步骤4: 脚本执行完成，结果:', result);

                    if (!result || !result[0] || result[0].result === undefined) {
                        reject(new Error('未能提取到网页数据'));
                        return;
                    }

                    // 检查是否有错误
                    if (result[0].error) {
                        reject(new Error('脚本执行失败: ' + result[0].error));
                        return;
                    }

                    const extractedData = result[0].result;

                    // 构造完整的数据结构
                    const webpageData = {
                        customer_code: customerCode,
                        tobacco_list: extractedData.tobacco_list || [],
                        total_spec: extractedData.total_spec || 0,
                        total_qty: extractedData.total_qty || 0,
                        total_price: extractedData.total_price || 0
                    };


                    resolve(webpageData);

                }).catch((error) => {
                    reject(new Error('脚本执行失败: ' + error.message));
                });
            });
        });
    }

    /**
     * 提交数据到轻流API
     */
    function submitToQingflowAPI(webpageData) {
        // 正式API
        // const apiUrl = 'https://qingflow.com/api/qsource/76d3ddcd-7bad-4276-89c6-7e6ad5183fb0';
        // 测试API
        const apiUrl = 'https://qingflow.com/api/qsource/c1b223ad-904e-404d-a61e-eae7173fde99'

        console.log('📤 === 开始提交数据到轻流API ===');
        console.log('📤 API URL:', apiUrl);
        console.log('📤 提交的数据:', JSON.stringify(webpageData, null, 2));
        console.log('📤 数据大小:', JSON.stringify(webpageData).length, '字符');
        console.log('📤 步骤1: 准备发送fetch请求');

        return fetch(apiUrl, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify(webpageData)
        })
            .then(response => {
                console.log('📤 步骤2: 收到API响应');
                console.log('📤 === API响应信息 ===');
                console.log('📤 响应状态:', response.status);
                console.log('📤 响应状态文本:', response.statusText);
                console.log('📤 响应头:', Object.fromEntries(response.headers.entries()));

                if (!response.ok) {
                    const errorMsg = `API请求失败: ${response.status} ${response.statusText}`;
                    console.error('📤 API请求失败:', errorMsg);
                    throw new Error(errorMsg);
                }

                console.log('📤 步骤3: 开始解析响应JSON');
                return response.json();
            })
            .then(data => {
                console.log('📤 步骤4: JSON解析完成');
                console.log('📤 === API返回数据 ===');
                console.log('📤 返回数据:', data);
                console.log('📤 返回数据类型:', typeof data);
                console.log('📤 是否成功:', data.success);

                if (data.success === false) {
                    const errorMsg = data.message || '提交失败，未知错误';
                    console.error('📤 API返回失败:', errorMsg);
                    throw new Error(errorMsg);
                }

                console.log('📤 === 数据提交成功 ===');
                return data;
            })
            .catch(error => {
                console.error('📤 === API请求错误 ===');
                console.error('📤 错误类型:', error.name);
                console.error('📤 错误消息:', error.message);
                console.error('📤 错误堆栈:', error.stack);

                // 网络错误特殊处理
                if (error.name === 'TypeError' && error.message.includes('fetch')) {
                    console.error('📤 网络连接错误，可能是CORS问题或网络不可达');
                }

                throw error;
            });
    }

    // 注入到页面的函数 - 根据数据智能填写（按顺序逐行填写）
    function quickFillOrdersWithData(smokingData) {
        // 处理数据结构 - 支持直接的商品数组和嵌套结构
        let allProducts = [];

        if (Array.isArray(smokingData)) {
            // 检查第一个元素的结构来判断数据格式
            if (smokingData.length > 0) {
                const firstItem = smokingData[0];

                // 如果第一个元素有products属性，说明是嵌套结构
                if (firstItem && firstItem.products && Array.isArray(firstItem.products)) {
                    smokingData.forEach(item => {
                        if (item.products && Array.isArray(item.products)) {
                            allProducts = allProducts.concat(item.products);
                        }
                    });
                } else {
                    // 否则认为是直接的商品数组
                    console.log('[DEBUG] 检测到直接商品数组结构');
                    allProducts = smokingData;
                }
            }
        } else {
            console.log('无法处理的smokingData结构:', smokingData);
            return;
        }
        // 内嵌辅助函数：在订烟数据中查找匹配的商品
        // 增强的名称解析函数
        function parseName(name) {
            if (!name) return { base: '', spec: '' };
            // 统一处理全角/半角括号并去除前后空格
            const normalizedName = name.replace(/（/g, '(').replace(/）/g, ')').trim();
            // 匹配最后一个括号里的内容作为规格
            const match = normalizedName.match(/^(.*)\((.*)\)$/);
            if (match && match[1] && match[2]) {
                // 返回基础名称和规格
                return { base: match[1].trim(), spec: match[2].trim() };
            }
            // 如果没有括号，则全都是基础名称
            return { base: normalizedName, spec: '' };
        }

        // 商品匹配缓存
        const productMatchCache = new Map();

        // 预处理API商品数据，避免重复解析
        const preprocessedProducts = allProducts.map(product => {
            const productName = product.name || product.product_name;
            if (!productName) return null;

            const parsedName = parseName(productName);
            return {
                ...product,
                originalName: productName,
                parsedBase: parsedName.base,
                parsedSpec: parsedName.spec
            };
        }).filter(Boolean);

        function findMatchingProduct(products, productName) {
            // 检查缓存
            if (productMatchCache.has(productName)) {
                const cached = productMatchCache.get(productName);
                console.log('[DEBUG] 使用缓存结果 - 商品名称:', productName);
                return cached;
            }
            const webNameParts = parseName(productName);
            // 在预处理的商品列表中查找匹配
            const matched = preprocessedProducts.find(product => {
                // 基础名称和规格都必须完全一致
                const isMatch = product.parsedBase === webNameParts.base && product.parsedSpec === webNameParts.spec;
                if (isMatch) {
                    console.log('[DEBUG] 找到匹配商品:', product);
                }
                return isMatch;
            });

            // 缓存结果
            productMatchCache.set(productName, matched || null);
            console.log('[DEBUG] 最终匹配结果:', matched);
            return matched;
        }

        // 添加高亮样式到页面
        function addHighlightStyles() {
            if (!document.getElementById('tobacco-helper-styles')) {
                const style = document.createElement('style');
                style.id = 'tobacco-helper-styles';
                style.textContent = `
                    .tobacco-helper-filled {
                        background-color:rgb(0, 255, 89) !important;
                        border-left: 4px solidrgb(13, 238, 66) !important;
                        color: #0d3d18 !important;
                        transition: all 0.3s ease !important;
                    }
                    
                    .tobacco-helper-highlight {
                        background-color: #fff3e0 !important;
                        border-left: 4px solid #ff9800 !important;
                        color: #e65100 !important;
                        transition: all 0.3s ease !important;
                    }
                    
                    .tobacco-helper-scroll-indicator {
                        position: fixed;
                        top: 20px;
                        left: 20px;
                        transform: none;
                        background: rgba(76, 175, 80, 0.9);
                        color: white;
                        padding: 10px 15px;
                        border-radius: 25px;
                        font-size: 14px;
                        font-weight: bold;
                        box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
                        z-index: 1000;
                        animation: slideInFromLeft 0.5s ease-out;
                        transition: all 0.3s ease;
                    }
                    
                    .tobacco-helper-progress-bar {
                        position: fixed;
                        top: 0;
                        left: 0;
                        height: 8px;  /* 从4px增加到8px，使进度条更醒目 */
                        background: linear-gradient(90deg, #4CAF50, #81C784);
                        z-index: 1001;
                        transition: width 0.3s ease;
                        box-shadow: 0 4px 15px rgba(76, 175, 80, 0.6);  /* 增强阴影效果 */
                        border-radius: 0 0 4px 0;  /* 添加右下角圆角 */
                    }
                    
                    .tobacco-helper-row-enter {
                        animation: fadeInUp 0.6s ease-out;
                    }
                `;
                document.head.appendChild(style);
            }
        }

        // 显示滚动进度指示器
        function showScrollIndicator(currentFilledCount, totalExpectedCount) {
            let indicator = document.getElementById('tobacco-helper-scroll-indicator');
            if (!indicator) {
                indicator = document.createElement('div');
                indicator.id = 'tobacco-helper-scroll-indicator';
                indicator.className = 'tobacco-helper-scroll-indicator';
                document.body.appendChild(indicator);
            }

            // 获取预期填写的商品总数（从smokingData获取）
            let totalDataCount = 0;
            if (smokingData) {
                if (Array.isArray(smokingData)) {
                    totalDataCount = smokingData.length;
                } else if (smokingData.data && Array.isArray(smokingData.data)) {
                    totalDataCount = smokingData.data.length;
                }
            }

            // 计算基于预期填写数量的进度
            const progress = totalDataCount > 0 ? Math.round((currentFilledCount / totalDataCount) * 100) : 0;
            // 显示格式：当前填写数量/预期填写总数
            indicator.textContent = `填写进度: ${currentFilledCount}/${totalDataCount} (${progress}%)`;
            indicator.style.display = 'block';
        }

        // 显示进度条
        function showProgressBar(progress) {
            let progressBar = document.getElementById('tobacco-helper-progress-bar');
            if (!progressBar) {
                progressBar = document.createElement('div');
                progressBar.id = 'tobacco-helper-progress-bar';
                progressBar.className = 'tobacco-helper-progress-bar';
                document.body.appendChild(progressBar);
            }

            progressBar.style.width = `${progress}%`;
            progressBar.style.display = 'block';
        }

        // 隐藏滚动指示器
        function hideScrollIndicator() {
            const indicator = document.getElementById('tobacco-helper-scroll-indicator');
            const progressBar = document.getElementById('tobacco-helper-progress-bar');

            if (indicator) {
                indicator.style.display = 'none';
            }
            if (progressBar) {
                progressBar.style.display = 'none';
            }
        }

        // 添加行进入动画
        function addRowEnterAnimation(row) {
            row.classList.add('tobacco-helper-row-enter');
            setTimeout(() => {
                row.classList.remove('tobacco-helper-row-enter');
            }, 600);
        }

        // 清除所有高亮样式
        function clearAllHighlights() {
            const rows = document.querySelectorAll('.cq_buy_main_grid_row[name="buy_dtl"]');
            rows.forEach(row => {
                row.classList.remove('tobacco-helper-current', 'tobacco-helper-filled', 'tobacco-helper-highlight', 'tobacco-helper-error');
            });
        }

        // 智能滚动函数 - 确保元素在最佳可视位置
        function smartScrollToElement(element, options = {}) {
            const {
                behavior = 'smooth',
                block = 'center',
                inline = 'nearest',
                offset = 0,
                duration = 800,
                easing = 'ease-out'
            } = options;

            // 获取元素和视口信息
            const elementRect = element.getBoundingClientRect();
            const viewportHeight = window.innerHeight;
            const viewportWidth = window.innerWidth;

            // 检查元素是否已经在理想位置 - 更严格的条件，确保滚动能够触发
            const isInOptimalPosition = (
                elementRect.top >= viewportHeight * 0.3 &&
                elementRect.bottom <= viewportHeight * 0.7 &&
                elementRect.left >= -50 &&
                elementRect.right <= viewportWidth + 50
            );

            // 强制执行滚动，不跳过任何情况，确保焦点功能正常
            console.log('强制执行滚动动画，确保焦点定位准确');

            // 计算目标滚动位置
            const currentScrollTop = window.pageYOffset || document.documentElement.scrollTop;
            const currentScrollLeft = window.pageXOffset || document.documentElement.scrollLeft;

            let targetScrollTop = currentScrollTop;
            let targetScrollLeft = currentScrollLeft;

            // 垂直滚动计算 - 优化center模式
            switch (block) {
                case 'start':
                    targetScrollTop = currentScrollTop + elementRect.top - Math.abs(offset);
                    break;
                case 'center':
                    // 确保元素在视口中心，考虑offset
                    targetScrollTop = currentScrollTop + elementRect.top - (viewportHeight / 2) + (elementRect.height / 2) + offset;
                    break;
                case 'end':
                    targetScrollTop = currentScrollTop + elementRect.bottom - viewportHeight - Math.abs(offset);
                    break;
                case 'nearest':
                    if (elementRect.top < 0) {
                        targetScrollTop = currentScrollTop + elementRect.top - Math.abs(offset);
                    } else if (elementRect.bottom > viewportHeight) {
                        targetScrollTop = currentScrollTop + elementRect.bottom - viewportHeight - Math.abs(offset);
                    }
                    break;
            }

            // 水平滚动计算
            switch (inline) {
                case 'start':
                    targetScrollLeft = currentScrollLeft + elementRect.left - Math.abs(offset);
                    break;
                case 'center':
                    targetScrollLeft = currentScrollLeft + elementRect.left - (viewportWidth / 2) + (elementRect.width / 2);
                    break;
                case 'end':
                    targetScrollLeft = currentScrollLeft + elementRect.right - viewportWidth - Math.abs(offset);
                    break;
                case 'nearest':
                    if (elementRect.left < 0) {
                        targetScrollLeft = currentScrollLeft + elementRect.left - Math.abs(offset);
                    } else if (elementRect.right > viewportWidth) {
                        targetScrollLeft = currentScrollLeft + elementRect.right - viewportWidth - Math.abs(offset);
                    }
                    break;
            }

            // 边界检查
            const maxScrollTop = Math.max(0, document.documentElement.scrollHeight - viewportHeight);
            const maxScrollLeft = Math.max(0, document.documentElement.scrollWidth - viewportWidth);

            targetScrollTop = Math.max(0, Math.min(targetScrollTop, maxScrollTop));
            targetScrollLeft = Math.max(0, Math.min(targetScrollLeft, maxScrollLeft));

            console.log(`滚动目标: 从 (${currentScrollLeft}, ${currentScrollTop}) 到 (${targetScrollLeft}, ${targetScrollTop})`);

            // 强制使用自定义滚动实现以确保可控性
            return new Promise((resolve) => {
                const startTime = performance.now();
                const startScrollTop = currentScrollTop;
                const startScrollLeft = currentScrollLeft;
                const distanceTop = targetScrollTop - startScrollTop;
                const distanceLeft = targetScrollLeft - startScrollLeft;

                // 如果距离很小，仍然执行动画以确保视觉反馈
                if (Math.abs(distanceTop) < 5 && Math.abs(distanceLeft) < 5) {
                    console.log('滚动距离很小，但仍执行动画以确保焦点效果');
                    // 即使距离很小，也要执行完整的动画流程
                }

                // 缓动函数
                const easingFunctions = {
                    'ease-out': t => 1 - Math.pow(1 - t, 3),
                    'ease-in': t => t * t * t,
                    'ease-in-out': t => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2,
                    'linear': t => t
                };

                const easingFunction = easingFunctions[easing] || easingFunctions['ease-out'];

                function animateScroll(currentTime) {
                    const elapsed = currentTime - startTime;
                    const progress = Math.min(elapsed / duration, 1);
                    const easedProgress = easingFunction(progress);

                    const currentTop = startScrollTop + (distanceTop * easedProgress);
                    const currentLeft = startScrollLeft + (distanceLeft * easedProgress);

                    window.scrollTo(currentLeft, currentTop);

                    if (progress < 1) {
                        requestAnimationFrame(animateScroll);
                    } else {
                        console.log('滚动动画完成');
                        resolve();
                    }
                }

                requestAnimationFrame(animateScroll);
            });
        }

        // 增强的表格行滚动函数
        function scrollToTableRow(row, index, options = {}) {
            const defaultOptions = {
                behavior: 'smooth',
                block: 'center',
                offset: -50, // 向上偏移50px，确保有足够的上下文
                duration: 600,
                easing: 'ease-out',
                force: false  // 新增强制滚动参数
            };

            const finalOptions = { ...defaultOptions, ...options };

            // 添加滚动前的视觉提示
            row.style.transition = 'all 0.3s ease';

            // 强制滚动模式或检查元素是否在视口中
            if (finalOptions.force || !isElementInViewport(row)) {
                console.log(`开始滚动到第 ${index + 1} 行 (强制模式: ${finalOptions.force})`);

                return smartScrollToElement(row, finalOptions).then(() => {
                    console.log(`滚动到第 ${index + 1} 行完成，焦点已定位`);

                    // 滚动完成后的回调
                    if (finalOptions.onComplete) {
                        finalOptions.onComplete(row, index);
                    }
                });
            } else {
                console.log(`第 ${index + 1} 行已在视口中，但仍执行回调`);
                // 即使跳过滚动，也要执行回调
                if (finalOptions.onComplete) {
                    finalOptions.onComplete(row, index);
                }
                return Promise.resolve();
            }
        }

        // 检查元素是否在视口中 - 优化检测逻辑
        function isElementInViewport(element, threshold = 0.3) {
            if (!element) return false;

            const rect = element.getBoundingClientRect();
            const viewportHeight = window.innerHeight;
            const viewportWidth = window.innerWidth;

            // 更宽松的视口检测条件，确保滚动能够正常触发
            const verticalInView = (
                rect.top >= -rect.height * (1 - threshold) &&
                rect.bottom <= viewportHeight + rect.height * (1 - threshold) &&
                rect.top < viewportHeight * 0.9  // 确保元素不在底部边缘
            );

            const horizontalInView = (
                rect.left >= -rect.width * (1 - threshold) &&
                rect.right <= viewportWidth + rect.width * (1 - threshold)
            );

            const isVisible = verticalInView && horizontalInView;

            // 添加调试信息
            if (!isVisible) {
                console.log(`元素不在最佳视口位置: top=${rect.top.toFixed(1)}, bottom=${rect.bottom.toFixed(1)}, viewportHeight=${viewportHeight}`);
            }

            return isVisible;
        }

        // 填写单行数据
        function fillSingleRow(row, index, matchedProduct) {
            // 设置需求量（实际上就是订购量）
            const reqQtyContainer = row.querySelector('.cq_buy_main_grid_c5.req_qty_container');
            if (reqQtyContainer) {
                const reqQtyInput = reqQtyContainer.querySelector('input[name="req_qty"]');
                if (reqQtyInput) {
                    // 设置需求量为API返回的order_quantity值或default_quantity值
                    const orderQuantity = matchedProduct.order_quantity || matchedProduct.default_quantity || 0;
                    reqQtyInput.value = orderQuantity.toString();
                    // 触发输入事件
                    ['input', 'change', 'blur', 'focus'].forEach(eventType => {
                        reqQtyInput.dispatchEvent(new Event(eventType, { bubbles: true }));
                    });

                    // 点击加号按钮来确保值被正确设置和计算
                    const addButton = reqQtyContainer.querySelector('.buy_main_grid_add');
                    if (addButton) {
                        // 先点击一次加号，再点击减号，确保触发计算逻辑
                        addButton.click();
                        setTimeout(() => {
                            const minusButton = reqQtyContainer.querySelector('.buy_main_grid_del');
                            if (minusButton) {
                                minusButton.click();
                            }
                        }, 50);
                    }

                    // 根据订购量应用颜色标记
                    setTimeout(() => {
                        // 获取商品名称用于调试
                        const productNameElement = row.querySelector('.cq_buy_main_product_name[name="product_name"]');
                        const productName = productNameElement ? productNameElement.getAttribute('title') || productNameElement.textContent.trim() : '未知商品';

                        // 多种方式获取实际的订购量值
                        let actualQuantity = 0;
                        let detectionMethod = '';

                        // 方式1：尝试从div[name="qty"]获取
                        const actualQtyDiv = row.querySelector('.cq_buy_main_grid_c6[name="qty"]');
                        if (actualQtyDiv) {
                            const textContent = actualQtyDiv.textContent.trim();
                            actualQuantity = parseInt(textContent) || 0;
                            detectionMethod = 'div[name="qty"]';
                            console.log(`第 ${index + 1} 行 "${productName}"，从${detectionMethod}获取订购量: "${textContent}" -> ${actualQuantity}`);
                        }

                        // 方式2：如果方式1失败，尝试从.cq_buy_main_grid_c6直接获取
                        if (actualQuantity === 0) {
                            const qtyContainer = row.querySelector('.cq_buy_main_grid_c6');
                            if (qtyContainer) {
                                const textContent = qtyContainer.textContent.trim();
                                actualQuantity = parseInt(textContent) || 0;
                                detectionMethod = '.cq_buy_main_grid_c6';
                                console.log(`第 ${index + 1} 行 "${productName}"，从${detectionMethod}获取订购量: "${textContent}" -> ${actualQuantity}`);
                            }
                        }

                        // 方式3：如果还是0，检查是否有input元素
                        if (actualQuantity === 0) {
                            const qtyInput = row.querySelector('.cq_buy_main_grid_c6 input');
                            if (qtyInput) {
                                const inputValue = qtyInput.value;
                                actualQuantity = parseInt(inputValue) || 0;
                                detectionMethod = 'input';
                                console.log(`第 ${index + 1} 行 "${productName}"，从${detectionMethod}获取订购量: "${inputValue}" -> ${actualQuantity}`);
                            }
                        }

                        // 方式4：如果仍然是0，尝试从需求量输入框获取（可能页面结构特殊）
                        if (actualQuantity === 0) {
                            const reqQtyInput = row.querySelector('input[name="req_qty"]');
                            if (reqQtyInput) {
                                const reqValue = reqQtyInput.value;
                                actualQuantity = parseInt(reqValue) || 0;
                                detectionMethod = 'req_qty input';
                                console.log(`第 ${index + 1} 行 "${productName}"，从${detectionMethod}获取订购量: "${reqValue}" -> ${actualQuantity}`);
                            }
                        }

                        console.log(`🔍 第 ${index + 1} 行 "${productName}" 高亮检测详情:`);
                        console.log(`   - API预期订购量: ${orderQuantity}`);
                        console.log(`   - 实际页面订购量: ${actualQuantity}`);
                        console.log(`   - 检测方式: ${detectionMethod}`);
                        console.log(`   - 匹配商品信息:`, matchedProduct);

                        if (actualQuantity > 0) {
                            // 实际订购量大于0时，标记为绿色（填写完成）
                            row.classList.add('tobacco-helper-filled');
                            row.classList.remove('tobacco-helper-highlight');
                            console.log(`✅ 第 ${index + 1} 行 "${productName}"，订购量 ${actualQuantity} > 0，添加绿色高亮`);
                        } else {
                            // 实际订购量等于0时，禁用高亮显示，移除所有高亮样式
                            console.log(`❌ 第 ${index + 1} 行 "${productName}"，实际订购量为0，禁用高亮显示`);
                            row.classList.remove('tobacco-helper-filled', 'tobacco-helper-highlight');
                        }

                        // 特殊调试：如果API预期有订购量但实际检测为0，输出详细信息
                        if (orderQuantity > 0 && actualQuantity === 0) {
                            console.warn(`⚠️ 异常检测: 第 ${index + 1} 行 "${productName}" API预期订购量${orderQuantity}但实际检测为0`);
                            console.warn(`   - 行元素:`, row);
                            console.warn(`   - 订购量容器元素:`, row.querySelector('.cq_buy_main_grid_c6'));
                            console.warn(`   - 所有可能的订购量元素:`, {
                                'div[name="qty"]': row.querySelector('.cq_buy_main_grid_c6[name="qty"]'),
                                '.cq_buy_main_grid_c6': row.querySelector('.cq_buy_main_grid_c6'),
                                'input': row.querySelector('.cq_buy_main_grid_c6 input'),
                                'req_qty input': row.querySelector('input[name="req_qty"]')
                            });
                        }
                    }, 1000); // 增加延迟时间到1000ms，确保页面完全更新

                    console.log(`第 ${index + 1} 行，需求量设置为 ${orderQuantity}`);
                    return true;
                } else {
                    console.log(`第 ${index + 1} 行，未找到需求量输入框`);
                    return false;
                }
            } else {
                console.log(`第 ${index + 1} 行，未找到需求量容器`);
                return false;
            }
        }

        // 按顺序填写的主函数
        function processRowsSequentially(rows, allProducts, filledCount) {
            // 过滤出有效的数据行（包含商品名称的行）
            const validRows = Array.from(rows).filter(row => {
                const productNameElement = row.querySelector('.cq_buy_main_product_name[name="product_name"]');
                if (!productNameElement) return false;

                const productName = productNameElement.getAttribute('title') || productNameElement.textContent.trim();
                return productName && productName.length > 0;
            });

            console.log(`总行数: ${rows.length}, 有效数据行: ${validRows.length}`);

            let currentIndex = 0;
            const totalRows = validRows.length; // 使用有效行数作为总数
            let successfullyFilledCount = 0; // 新增：成功填写的商品计数器
            const highlightedItems = []; // 在处理过程中收集需要高亮的商品信息
            const filledItems = []; // 收集本次填写的香烟信息（订购量不为0的记录）
            let zeroCount = 0;

            // 显示进度指示器 - 初始化时显示0填写进度
            // 获取预期填写的商品总数
            let totalDataCount = 0;
            if (smokingData) {
                if (Array.isArray(smokingData)) {
                    totalDataCount = smokingData.length;
                } else if (smokingData.data && Array.isArray(smokingData.data)) {
                    totalDataCount = smokingData.data.length;
                }
            }
            showScrollIndicator(0, totalDataCount);
            showProgressBar(0);

            function processNextRow() {
                if (currentIndex >= validRows.length) {
                    // 所有行处理完成，隐藏进度指示器
                    hideScrollIndicator();

                    // 执行后续逻辑
                    setTimeout(() => {
                        // 构造并显示详细的弹窗提示 - 显示本次填写的香烟信息
                        let msg = `快速填写完成！\n\n本次填写的香烟信息：\n`;

                        if (filledItems.length > 0) {
                            msg += filledItems.map(item => `${item.name}: ${item.quantity}条`).join('\n');
                            msg += `\n\n共填写 ${filledItems.length} 种香烟`;
                        } else {
                            msg += '本次未填写任何香烟（所有订购量均为0）';
                        }
                        alert(msg);
                        console.log(`已填充 ${filledCount} 个商品的订购量，${zeroCount} 个商品满足高亮条件`);
                    }, 500);
                    return;
                }

                const row = validRows[currentIndex]; // 使用有效行数组

                // 获取商品名称 - 从title属性获取
                const productNameElement = row.querySelector('.cq_buy_main_product_name[name="product_name"]');
                if (!productNameElement) {
                    console.warn(`第 ${currentIndex + 1} 行，未找到商品名称元素（这不应该发生，因为已经过滤了有效行）`);
                    currentIndex++;
                    setTimeout(processNextRow, 100);
                    return;
                }

                const productName = productNameElement.getAttribute('title') || productNameElement.textContent.trim();
                console.log(`[DEBUG] 第 ${currentIndex + 1} 行处理开始，当前successfullyFilledCount: ${successfullyFilledCount}`);
                console.log(`第 ${currentIndex + 1} 行商品名称: ${productName}`);

                // 在扁平化的商品列表中查找匹配的商品
                const matchedProduct = findMatchingProduct(allProducts, productName);
                console.log(`[DEBUG] 第 ${currentIndex + 1} 行，findMatchingProduct返回结果:`, matchedProduct);

                if (!matchedProduct) {
                    console.log(`第 ${currentIndex + 1} 行，未找到匹配的订烟数据`);

                    // 检查是否需要高亮（有需求但无匹配数据的情况）
                    checkAndHighlightRow(row, currentIndex, productName);

                    // 未匹配的商品不更新填写进度，只更新遍历进度
                    // 这里不增加successfullyFilledCount，保持进度显示为实际填写数量
                    console.log(`[DEBUG] 第 ${currentIndex + 1} 行未匹配，successfullyFilledCount保持: ${successfullyFilledCount}`);

                    currentIndex++;
                    setTimeout(processNextRow, 100); // 短暂延迟后处理下一行
                    return;
                }

                console.log(`第 ${currentIndex + 1} 行，匹配到商品:`, matchedProduct);

                // 填写当前行
                const success = fillSingleRow(row, currentIndex, matchedProduct);
                console.log(`[DEBUG] 第 ${currentIndex + 1} 行，fillSingleRow返回结果: ${success}`);

                if (success) {
                    filledCount++;
                    successfullyFilledCount++; // 增加成功填写计数
                    console.log(`[DEBUG] 第 ${currentIndex + 1} 行填写成功，successfullyFilledCount更新为: ${successfullyFilledCount}`);

                    // 收集填写的香烟信息（仅收集订购量不为0的记录）
                    const orderQuantity = matchedProduct.order_quantity || matchedProduct.default_quantity || 0;
                    if (orderQuantity > 0) {
                        filledItems.push({
                            name: productName,
                            quantity: orderQuantity
                        });
                    }

                    // 检查填写后是否需要高亮
                    setTimeout(() => {
                        checkAndHighlightRow(row, currentIndex, productName);
                    }, 300); // 等待填写完成后再检查
                } else {
                    console.log(`[DEBUG] 第 ${currentIndex + 1} 行填写失败，successfullyFilledCount保持: ${successfullyFilledCount}`);
                }

                // 更新进度 - 基于成功填写的数量而不是遍历数量
                // 获取预期填写的商品总数用于进度条计算
                let totalDataCount = 0;
                if (smokingData) {
                    if (Array.isArray(smokingData)) {
                        totalDataCount = smokingData.length;
                    } else if (smokingData.data && Array.isArray(smokingData.data)) {
                        totalDataCount = smokingData.data.length;
                    }
                }
                const progress = totalDataCount > 0 ? Math.round((successfullyFilledCount / totalDataCount) * 100) : 0;
                console.log(`[DEBUG] 进度更新 - successfullyFilledCount: ${successfullyFilledCount}, totalDataCount: ${totalDataCount}, progress: ${progress}%`);
                showScrollIndicator(successfullyFilledCount, totalDataCount);
                showProgressBar(progress);

                currentIndex++;

                // 延迟后处理下一行，让用户看到动画效果
                setTimeout(processNextRow, 500);
            }

            // 检查并高亮行的辅助函数
            function checkAndHighlightRow(row, index, productName) {
                // 简化逻辑：不再进行额外的高亮检查
                // 颜色标记已在fillSingleRow函数中根据订购量进行处理
                console.log(`第 ${index + 1} 行检查完成: ${productName}`);
            }

            processNextRow();
        }

        // 添加样式
        addHighlightStyles();

        // 清除之前的高亮
        clearAllHighlights();

        const rows = document.querySelectorAll('.cq_buy_main_grid_row[name="buy_dtl"]');
        let filledCount = 0;

        console.log(`找到 ${rows.length} 个商品行`);
        console.log('订烟数据:', smokingData);

        // 启动按顺序填写
        processRowsSequentially(rows, allProducts, filledCount);
        setTimeout(() => {
            updateOperationHistoryDisplay();
        }, 800); // 适当增加延时以确保DOM更新完毕
    }

    /**
     * 更新订烟数据显示
     */
    function updateSmokingDataDisplay(data) {
        console.log('updateSmokingDataDisplay 接收到的数据:', data);

        // 检查数据是否为空
        if (!data) {
            smokingDataContainer.innerHTML = `
            <div class="data-placeholder">
                <span class="placeholder-icon">📊</span>
                <p>暂无必定烟表数据</p>
            </div>
        `;
            return;
        }

        // 处理API返回的数据格式 - fixed_tobacco_table返回的是直接的香烟数组
        let tobaccoList = [];

        // 如果data是数组，直接使用
        if (Array.isArray(data)) {
            tobaccoList = data;
        }
        // 如果data是对象且有data属性，使用data.data
        else if (data && Array.isArray(data.data)) {
            tobaccoList = data.data;
        }
        // 如果data是单个对象，包装成数组
        else if (data && typeof data === 'object') {
            tobaccoList = [data];
        }

        console.log('处理后的香烟列表:', tobaccoList);

        if (tobaccoList.length === 0) {
            smokingDataContainer.innerHTML = `
            <div class="data-placeholder">
                <span class="placeholder-icon">📊</span>
                <p>暂无香烟数据</p>
            </div>
        `;
            return;
        }

        // 计算平均批发价
        const avgWholesalePrice = tobaccoList.reduce((sum, tobacco) => sum + (tobacco.wholesale_price || 0), 0) / tobaccoList.length;

        const dataList = tobaccoList.map(tobacco => `
            <div class="smoking-item">
                <span class="smoking-name">${tobacco.name || '未知香烟'}</span>
                <span class="smoking-price">批发价: ¥${tobacco.wholesale_price || 0}</span>
                <span class="smoking-price">零售价: ¥${tobacco.retail_price || 0}</span>
                <span class="smoking-quantity">默认量: ${tobacco.default_quantity || 0}</span>
                <span class="smoking-category">分类: ${tobacco.category || '未分类'}</span>
            </div>
        `).join('');

        smokingDataContainer.innerHTML = `
        <div class="smoking-data-list">
            <div class="data-header">
                <h4>必定烟表数据 (共${tobaccoList.length}种香烟，平均批发价: ¥${avgWholesalePrice.toFixed(2)})</h4>
            </div>
            ${dataList}
        </div>
    `;
    }

    // 订烟数据持久化相关
    function saveSmokingDataToStorage(data) {
        console.log('[DEBUG] 保存smokingData到存储，数据数量:', data ? data.length : 0);
        chrome.storage.local.set({ smokingData: data }, () => {
            console.log('[DEBUG] 订烟数据已持久化到chrome.storage.local');
        });
    }

    function loadSmokingDataFromStorage() {
        chrome.storage.local.get('smokingData', (result) => {
            console.log('[DEBUG] 从存储中加载smokingData:', result);
            if (result.smokingData) {
                console.log('[DEBUG] 存储中的smokingData数量:', result.smokingData.length);
                smokingData = result.smokingData; // 确保将数据赋值给全局变量
                updateSmokingDataDisplay(result.smokingData);
            } else {
                console.log('[DEBUG] 存储中没有smokingData，需要先获取数据');
                smokingData = null;
            }
        });
    }

    // 在 popup 页面加载时自动读取并展示已保存的数据
    console.log('=== 第二个DOMContentLoaded检查 ===');
    console.log('检查文档加载状态:', document.readyState);
    if (document.readyState === 'loading') {
        console.log('文档正在加载，添加第二个DOMContentLoaded监听器');
        document.addEventListener('DOMContentLoaded', loadSmokingDataFromStorage);
    } else {
        console.log('文档已加载完成，直接调用loadSmokingDataFromStorage');
        loadSmokingDataFromStorage();
    }

    /**
     * 重置插件UI到初始状态
     */
    function resetUI() {
        console.log("接收到重置指令，UI将恢复初始状态。");
        smokingData = null; // 清空内存中的数据
        updateSmokingDataDisplay(null); // 更新数据显示区域为空状态
        updateCustomerCode('未获取'); // 重置客户编码显示

        // 重置页面状态和消息提示
        pageStatusEl.textContent = '检测中...';
        pageStatusEl.className = 'info-value status-unknown';
        statusMessageEl.classList.add('hidden');
        statusMessageEl.querySelector('.status-text').textContent = '准备就绪';

        // 清空并更新操作历史
        operationHistoryData = [];
        addOperationHistory('缓存', '已清空', '因页面刷新，缓存数据已被清除');
    }

    // 监听来自后台脚本的消息，用于重置UI
    chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
        if (request.action === 'dataCleared') {
            resetUI();
            sendResponse({ success: true });
        }
        return true; // 建议为所有消息监听器返回true，以处理可能的异步响应
    });
});

